{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "save_and_serialize.ipynb",
      "provenance": [],
      "private_outputs": true,
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "mHDxn9VHjxKn"
      },
      "source": [
        "##### Copyright 2019 The TensorFlow Authors."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "colab_type": "code",
        "id": "3x19oys5j89H",
        "colab": {}
      },
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "hFDUpbtvv_3u"
      },
      "source": [
        "# Guardando y Serializando Modelos con TensorFlow Keras"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "V94_3U2k9rWV"
      },
      "source": [
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://www.tensorflow.org/guide/keras/save_and_serialize\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" />Ver en TensorFlow.org</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs/blob/master/site/es/guide/keras/save_and_serialize.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Ejecutar en Google Colab</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://github.com/tensorflow/docs/blob/master/site/es/guide/keras/save_and_serialize.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />Ver fuente en GitHub</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a href=\"https://storage.googleapis.com/tensorflow_docs/docs/site/es/guide/keras/save_and_serialize.ipynb\"><img src=\"https://www.tensorflow.org/images/download_logo_32px.png\" />Descargar notas</a>\n",
        "  </td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Px0f1zDWUik3",
        "colab_type": "text"
      },
      "source": [
        "Note: Nuestra comunidad de Tensorflow ha traducido estos documentos. Como las traducciones de la comunidad\n",
        "son basados en el \"mejor esfuerzo\", no hay ninguna garantia que esta sea un reflejo preciso y actual \n",
        "de la [Documentacion Oficial en Ingles](https://www.tensorflow.org/?hl=en).\n",
        "Si tienen sugerencias sobre como mejorar esta traduccion, por favor envian un \"Pull request\"\n",
        "al siguiente repositorio [tensorflow/docs](https://github.com/tensorflow/docs).\n",
        "Para ofrecerse como voluntario o hacer revision de las traducciones de la Comunidad\n",
        "por favor contacten al siguiente grupo [docs@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ZwiVWAQc9tk7"
      },
      "source": [
        "La primera parte de esta guia cubre el guardado y serialización para modelos secuenciales y modelos creados con la API funcional y para modelos secuenciales. Las APIs de guardado y serialización son exactamente las mismas para ambos tipos de modelos.\n",
        "\n",
        "El guardado para las subclases personalizadas de Modelo se explica en la sección \"Guardar modelos de subclases\". Las APIs en este caso son ligeramente diferentes a las de los modelos secuenciales o funcionales."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "uqSgPMHguAAs"
      },
      "source": [
        "## Configurar"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "bx5w4U5muDAo",
        "colab": {}
      },
      "source": [
        "from __future__ import absolute_import, division, print_function, unicode_literals\n",
        "\n",
        "try:\n",
        "  # %tensorflow_version solo existe en Colab.\n",
        "  %tensorflow_version 2.x\n",
        "except Exception:\n",
        "  pass\n",
        "import tensorflow as tf\n",
        "\n",
        "tf.keras.backend.clear_session()  # Para restablecer fácilmente el estado del portátil."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "wwCxkE6RyyPy"
      },
      "source": [
        "## Parte I: Guardar modelos secuenciales o modelos funcionales\n",
        "\n",
        "Consideremos el siguiente modelo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "ILmySACTvSA9",
        "colab": {}
      },
      "source": [
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "\n",
        "inputs = keras.Input(shape=(784,), name='digits')\n",
        "x = layers.Dense(64, activation='relu', name='dense_1')(inputs)\n",
        "x = layers.Dense(64, activation='relu', name='dense_2')(x)\n",
        "outputs = layers.Dense(10, activation='softmax', name='predictions')(x)\n",
        "\n",
        "model = keras.Model(inputs=inputs, outputs=outputs, name='3_layer_mlp')\n",
        "model.summary()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "xPRqbd0yw8hY"
      },
      "source": [
        "Opcionalmente, entrenaremos este modelo, solo para que tenga valores de peso para guardarlos, así como un estado optimizador. Por supuesto, tambien puede guardar modelos que nunca ha entrenado, pero obviamente eso es menos interesante."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "gCygTeGQw74g",
        "colab": {}
      },
      "source": [
        "(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()\n",
        "x_train = x_train.reshape(60000, 784).astype('float32') / 255\n",
        "x_test = x_test.reshape(10000, 784).astype('float32') / 255\n",
        "\n",
        "model.compile(loss='sparse_categorical_crossentropy',\n",
        "              optimizer=keras.optimizers.RMSprop())\n",
        "history = model.fit(x_train, y_train,\n",
        "                    batch_size=64,\n",
        "                    epochs=1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "htnmbhz-iOwh",
        "colab": {}
      },
      "source": [
        "# Guardar predicciones para futuras verificaciones\n",
        "predictions = model.predict(x_test)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "opP1KROHwWwd"
      },
      "source": [
        "\n",
        "### Modelo-Completo Guardando\n",
        "\n",
        "Puede guardar un modelo creado con la API funcional en un solo archivo. Posteriormente, puede volver a crear el mismo modelo a partir de este archivo, incluso si ya no tiene acceso al codigo que creo el modelo.\n",
        "\n",
        "Este archivo incluye:\n",
        "\n",
        "- Los modelos de arquitectura\n",
        "- Los valores de peso del modelo (que se aprendieron durante el entrenamiento)\n",
        "- La configuración de entrenamiento del modelo (lo que pasó a 'compilar'), si corresponde\n",
        "- El optimizador y su estado, si corresponde (esto le permite reiniciar el entrenamiento donde lo dejó)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "HqHvq6Igw3wx",
        "colab": {}
      },
      "source": [
        "# Guardar el Modelo\n",
        "model.save('path_to_my_model.h5')\n",
        "\n",
        "# Recrea exactamente el mismo modelo solo desde el archivo\n",
        "new_model = keras.models.load_model('path_to_my_model.h5')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "mmIcF6UOItJE",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# Verifique que el estado esté preservado\n",
        "new_predictions = new_model.predict(x_test)\n",
        "np.testing.assert_allclose(predictions, new_predictions, rtol=1e-6, atol=1e-6)\n",
        "\n",
        "# Tenga en cuenta que el estado del optimizador también se conserva:\n",
        "# puede reanudar el entrenamiento donde lo dejó."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "-WEPW3n8ICyz"
      },
      "source": [
        "### Exportar a 'SavedModel'\n",
        "\n",
        "Tambien puede exportar un modelo completo al formato 'SavedModel' de TensorFlow. 'SavedModel' es un formato de serialización independiente para objetos de Tensorflow, compatible con el servicio de TensorFlow y las implementaciones de TensorFlow que no sean Python.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "cKASRTKCU5nv",
        "colab": {}
      },
      "source": [
        "# Exportar el modelo a 'SavedModel'\n",
        "keras.experimental.export_saved_model(model, 'path_to_saved_model')\n",
        "\n",
        "# Recrea exactamente el mismo modelo\n",
        "new_model = keras.experimental.load_from_saved_model('path_to_saved_model')\n",
        "\n",
        "# Verifique que el estado esté guardado\n",
        "new_predictions = new_model.predict(x_test)\n",
        "np.testing.assert_allclose(predictions, new_predictions, rtol=1e-6, atol=1e-6)\n",
        "\n",
        "# Tenga en cuenta que el estado del optimizador también se conserva:\n",
        "# puede reanudar el entrenamiento donde lo dejó."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "4AWgwkKWIhfj"
      },
      "source": [
        "Los archivos 'SavedModel' que se crearon contienen:\n",
        "\n",
        "- Un punto de control TensorFlow que contiene los pesos del modelo.\n",
        "- Un prototipo 'SavedModel' que contiene el grafico subyacente de Tensorflow. Separar los graficos que se guardan para prediccion (servicio), capacitacion y evaluacion. Si el modelo no se compilo antes, solo el grafico de inferencia se exporta\n",
        "- La configuracion de arquitectura del modelo, si esta disponible."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "GkY8XP_XxgMI"
      },
      "source": [
        "### Solo arquitectura de guardado\n",
        "\n",
        "A veces, solo esta interesado en la arquitectura del modelo y no necesita guardar los valores de peso o el optimizador. En este caso, puede recuperar la \"configuracion\" del modelo mediante el metodo get_config (). La configuracion es un dict de Python que le permite recrear el mismo modelo, inicializado desde cero, sin ninguna de la información aprendida previamente durante el entrenamiento."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "yQGGvo2Fw4o-",
        "colab": {}
      },
      "source": [
        "config = model.get_config()\n",
        "reinitialized_model = keras.Model.from_config(config)\n",
        "\n",
        "# ¡Tenga en cuenta que el estado del modelo no se conserva! Solo guardamos la arquitectura.\n",
        "new_predictions = reinitialized_model.predict(x_test)\n",
        "assert abs(np.sum(predictions - new_predictions)) > 0."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "WsNBBvDgxsTS"
      },
      "source": [
        "Alternativamente, puede usar 'to_json()' de 'from_json ()', que usa una cadena JSON para almacenar la configuracion en lugar de un 'dict' de Python. Esto es util para guardar la configuracion en el disco."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "5a0z7_6XxqWV",
        "colab": {}
      },
      "source": [
        "json_config = model.to_json()\n",
        "reinitialized_model = keras.models.model_from_json(json_config)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vq0NONs-2QGL",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "SGC7R6IIxy0o"
      },
      "source": [
        "### Guardando solo con pesos\n",
        "\n",
        "A veces, solo le interesa el estado del modelo, sus valores de peso, y no la arquitectura. En este caso, puede recuperar los valores de pesos como una lista de matrices Numpy a traves de 'get_weights()', y establecer el estado del modelo a través de 'set_weights':"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "B8tHwEvkxw5E",
        "colab": {}
      },
      "source": [
        "weights = model.get_weights()  # Recupera el estado del modelo.\n",
        "model.set_weights(weights)  # Establece el estado del modelo."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Ydwtw-u2x7xC"
      },
      "source": [
        "Puede combinar get_config()/from_config() y get_weights()/set_weights() para recrear su modelo en el mismo estado. Sin embargo, a diferencia de model.save(), esto no incluira la configuracion de entrenamiento y el optimizado tendría que volver a llamar a compile() antes de usar el modelo para el entrenamiento."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "LWVtuxtrx5lb",
        "colab": {}
      },
      "source": [
        "config = model.get_config()\n",
        "weights = model.get_weights()\n",
        "\n",
        "new_model = keras.Model.from_config(config)\n",
        "new_model.set_weights(weights)\n",
        "\n",
        "# Verifique que el estado esté preservado\n",
        "new_predictions = new_model.predict(x_test)\n",
        "np.testing.assert_allclose(predictions, new_predictions, rtol=1e-6, atol=1e-6)\n",
        "\n",
        "# Tenga en cuenta que el optimizador no se conserva\n",
        "# entonces el modelo debe compilarse nuevamente antes de entrenar\n",
        "# (y el optimizador comenzará desde un estado en blanco)."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "prk0GzwCyIYy"
      },
      "source": [
        "La alternativa de guardar en disco a 'get_weights()' y 'set_weights(weights)' es 'save_weights(fpath)' y 'load_weights(fpath)'.\n",
        "\n",
        "Aquí hay un ejemplo que guarda en el disco:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "2irLnOUbyHlI",
        "colab": {}
      },
      "source": [
        "# Guardar configuración JSON en el disco\n",
        "json_config = model.to_json()\n",
        "with open('model_config.json', 'w') as json_file:\n",
        "    json_file.write(json_config)\n",
        "# Guardar pesos en el disco\n",
        "model.save_weights('path_to_my_weights.h5')\n",
        "\n",
        "# Recargue el modelo de los 2 archivos que guardamos\n",
        "with open('model_config.json') as json_file:\n",
        "    json_config = json_file.read()\n",
        "new_model = keras.models.model_from_json(json_config)\n",
        "new_model.load_weights('path_to_my_weights.h5')\n",
        "\n",
        "# Verifique que el estado esté preservado\n",
        "new_predictions = new_model.predict(x_test)\n",
        "np.testing.assert_allclose(predictions, new_predictions, rtol=1e-6, atol=1e-6)\n",
        "\n",
        "# Tenga en cuenta que el optimizador no se conservo."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "KBxcFAPHyYi5"
      },
      "source": [
        "Pero recuerde que la forma más simple y recomendada es solo esto:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "DE4b3ndNyQh3",
        "colab": {}
      },
      "source": [
        "model.save('path_to_my_model.h5')\n",
        "del model\n",
        "model = keras.models.load_model('path_to_my_model.h5')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "yKikmbdC3O_i"
      },
      "source": [
        "### Weights-only Guardando en formato 'SavedModel'\n",
        "\n",
        "Tenga en cuenta que 'save_weights' puede crear archivos en el formato Keras HDF5 o en el formato TensorFlow 'SavedModel'. El formato se infiere de la extension de archivo que proporciona: si es \".h5\" o \".keras\", el marco utiliza el formato Keras HDF5. Cualquier otra cosa por defecto es 'SavedModel'."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "0pYKb6LV3h2l",
        "colab": {}
      },
      "source": [
        "model.save_weights('path_to_my_tf_savedmodel')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ZFwKv6JC3kyu"
      },
      "source": [
        "Para una total explicidad, el formato se puede pasar explicitamente a traves del argumento 'save_format', que puede tomar el valor \"tf\" o \"h5\":"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "oN9vOaWU34lA",
        "colab": {}
      },
      "source": [
        "model.save_weights('path_to_my_tf_savedmodel', save_format='tf')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "xXgtNRCSyuIW"
      },
      "source": [
        "## Guardar modelos subclasificados"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "mJqOn0snzCRy"
      },
      "source": [
        "Los modelos secuenciales y los modelos funcionales son estructuras de datos que representan un DAG de capas. Como tal, se pueden serializar y deserializar de forma segura.\n",
        "\n",
        "Un modelo subclasificado difiere en que no es una estructura de datos, es una pieza de código. La arquitectura del modelo se define a través del cuerpo del método de llamada. Esto significa que la arquitectura del modelo no se puede serializar de forma segura. Para cargar un modelo, deberá tener acceso al código que lo creó (el código de la subclase de modelo). Alternativamente, podría estar serializando este código como bytecode (por ejemplo, mediante pickling), pero eso no es seguro y, en general, no es portátil.\n",
        "\n",
        "Para obtener más información sobre estas diferencias, vea el artículo [\"¿Qué son las API simbólicas e imperativas en TensorFlow 2.0?\"](https://medium.com/tensorflow/what-are-symbolic-and-imperative-apis-in-tensorflow-2-0-dfccecb01021)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Pkwyu5dVz12P"
      },
      "source": [
        "\n",
        "Consideremos el siguiente modelo subclasificado, que sigue la misma estructura que el modelo de la primera seccion:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "4Onp-8rGyeQG",
        "colab": {}
      },
      "source": [
        "class ThreeLayerMLP(keras.Model):\n",
        "\n",
        "  def __init__(self, name=None):\n",
        "    super(ThreeLayerMLP, self).__init__(name=name)\n",
        "    self.dense_1 = layers.Dense(64, activation='relu', name='dense_1')\n",
        "    self.dense_2 = layers.Dense(64, activation='relu', name='dense_2')\n",
        "    self.pred_layer = layers.Dense(10, activation='softmax', name='predictions')\n",
        "\n",
        "  def call(self, inputs):\n",
        "    x = self.dense_1(inputs)\n",
        "    x = self.dense_2(x)\n",
        "    return self.pred_layer(x)\n",
        "\n",
        "def get_model():\n",
        "  return ThreeLayerMLP(name='3_layer_mlp')\n",
        "\n",
        "model = get_model()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "wwT_YoKA0yQW"
      },
      "source": [
        "En primer lugar, *un modelo subclasificado que nunca se ha utilizado no se puede guardar.*.\n",
        "\n",
        "Esto se debe a que es necesario invocar un modelo subclasificado en algunos datos para crear sus pesos.\n",
        "\n",
        "Hasta que se haya llamado al modelo, no conoce la forma y el tipo de datos de entrada que debería ser\n",
        "esperando, y por lo tanto no puede crear sus variables de peso. Puede recordar que en el modelo funcional de la primera sección, la forma y el tipo de las entradas se especificaron de antemano (a través de 'keras.Input (...)'), por eso los modelos funcionales tienen un estado tan pronto como Estás instanciado.\n",
        "\n",
        "Vamos a entrenar el modelo para darle un estado:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "xqP4kIFN0fTZ",
        "colab": {}
      },
      "source": [
        "(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()\n",
        "x_train = x_train.reshape(60000, 784).astype('float32') / 255\n",
        "x_test = x_test.reshape(10000, 784).astype('float32') / 255\n",
        "\n",
        "model.compile(loss='sparse_categorical_crossentropy',\n",
        "              optimizer=keras.optimizers.RMSprop())\n",
        "history = model.fit(x_train, y_train,\n",
        "                    batch_size=64,\n",
        "                    epochs=1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "rvGCpyX72HOC"
      },
      "source": [
        "La forma recomendada de guardar un modelo subclasificado es usar 'save_weights' para crear un punto de control TensorFlow 'SavedModel', que contendra el valor de todas las variables asociadas con el modelo:\n",
        "- Los pesos de las capas\n",
        "- El estado del optimizador\n",
        "- Cualquier variable asociada con métricas de modelo con estado (si las hay)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "gMg87Tz01cxQ",
        "colab": {}
      },
      "source": [
        "model.save_weights('path_to_my_weights', save_format='tf')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "KOKNBojtsl0F",
        "colab": {}
      },
      "source": [
        "# Guardar predicciones para futuras verificaciones\n",
        "predictions = model.predict(x_test)\n",
        "# También guarde la pérdida en el primer lote\n",
        "# para luego afirmar que el estado del optimizador fue preservado\n",
        "first_batch_loss = model.train_on_batch(x_train[:64], y_train[:64])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "h2PM_PL1SzPo"
      },
      "source": [
        "Para restaurar su modelo, necesitará acceso al codigo que creó el objeto modelo.\n",
        "\n",
        "Tenga en cuenta que para restaurar el estado del optimizador y el estado de cualquier métrica con estado, debe compila el modelo (con los mismos argumentos que antes) y llámalo con algunos datos antes de llamar a 'load_weights':"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "OOSGiSkHTERy",
        "colab": {}
      },
      "source": [
        "# Recrea el modelo\n",
        "new_model = get_model()\n",
        "new_model.compile(loss='sparse_categorical_crossentropy',\n",
        "                  optimizer=keras.optimizers.RMSprop())\n",
        "\n",
        "# Esto inicializa las variables utilizadas por los optimizadores,\n",
        "# así como cualquier variable métrica con estado\n",
        "new_model.train_on_batch(x_train[:1], y_train[:1])\n",
        "\n",
        "# Cargue el estado del modelo anterior.\n",
        "new_model.load_weights('path_to_my_weights')\n",
        "\n",
        "# Compruebe que se ha conservado el estado del modelo.\n",
        "new_predictions = new_model.predict(x_test)\n",
        "np.testing.assert_allclose(predictions, new_predictions, rtol=1e-6, atol=1e-6)\n",
        "\n",
        "# El estado del optimizador también se conserva,\n",
        "# para que pueda reanudar el entrenamiento donde lo dejó\n",
        "new_first_batch_loss = new_model.train_on_batch(x_train[:64], y_train[:64])\n",
        "assert first_batch_loss == new_first_batch_loss"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "2_XaE5Oqv7Rh"
      },
      "source": [
        "You've reached the end of this guide! This covers everything you need to know about saving and serializing models with tf.keras in TensorFlow 2.0."
      ]
    }
  ]
}